const db = require("../config/mysql.js");

class DataLookModel {
    constructor() {
        this.db = db;
        // 定义关联表名
        this.tableName_daily = 'daily_logs';       // 经营情况表
        this.tableName_plan = 'goods_plan';        // 采购计划主表
        this.tableName_inventory = 'inventory';    // 库存表
        this.tableName_goods = 'goods';            // 食材表（关联库存表获取食材名称）
        this.tableName_category = 'category';        // 食材分类表
        this.tableName_goods_order = 'goods_order';  // 采购订单主表
        this.tableName_goods_order_item = 'goods_order_item'; // 采购订单明细表
        this.tableName_inventoryout = 'inventoryout';  // 出库主表
        this.tableName_inventoryout_item = 'inventoryoutitem'; // 出库明细表
        this.tableName_sys_logs = 'sys_logs';     // 系统日志表
        this.tableName_user = 'user'; // 新增/确认：用户表名（关联查询用）
    }

    /**
     * 1. 获取当日营业额（默认当天，支持指定日期）
     * @param {string} date - 日期（格式YYYY-MM-DD，默认当前日期）
     */
    async getTodaySales(date = null) {
        // 若未传日期，默认取当前日期
        const targetDate = date || new Date().toISOString().split('T')[0];

        const sql = `
            SELECT 
                log_date,
                total_sales AS totalSales,          -- 总营业额
                meal_sales AS mealSales,            -- 包餐营业额
                qcode_sales + card_sales + ticket_sales AS trainingSales,  -- 培训部总营业额
                room_food_sales AS roomSales,       -- 包间营业额
                food_cost AS totalFoodCost,         -- 食材总成本
                food_cost_ratio AS costRatio        -- 食材成本占比
            FROM ${this.tableName_daily}
            WHERE log_date = ?
            LIMIT 1
        `;

        const [result] = await this.db.query(sql, [targetDate]);
        // 处理包间营业额字段类型（数据库存为varchar，转为数字）
        if (result.length > 0) {
            result[0].roomSales = Number(result[0].roomSales) || 0;
            return result[0];
        }
        return null; // 无当日数据返回null
    }

    /**
     * 2. 获取当日就餐人数（默认当天，支持指定日期）
     * @param {string} date - 日期（格式YYYY-MM-DD，默认当前日期）
     */
    async getTodayDiningCount(date = null) {
        const targetDate = date || new Date().toISOString().split('T')[0];

        const sql = `
            SELECT 
                -- 包餐人数 + 培训部各类用餐人数总和
                (meal_count + qcode_count + card_count + ticket_count) AS totalDiningCount,
                meal_count AS mealDiningCount,        -- 包餐就餐人数
                qcode_count AS qcodeDiningCount,      -- 培训部二维码用餐人数
                card_count AS cardDiningCount,        -- 培训部卡机用餐人数
                ticket_count AS ticketDiningCount     -- 培训部餐票挂账人数
            FROM ${this.tableName_daily}
            WHERE log_date = ?
            LIMIT 1
        `;

        const [result] = await this.db.query(sql, [targetDate]);
        console.log("当日用餐人数查询结果：", sql, result);

        // 处理空数据情况，默认返回0
        if (result.length > 0) {
            return {
                totalDiningCount: Number(result[0].totalDiningCount) || 0,
                mealDiningCount: Number(result[0].mealDiningCount) || 0,
                qcodeDiningCount: Number(result[0].qcodeDiningCount) || 0,
                cardDiningCount: Number(result[0].cardDiningCount) || 0,
                ticketDiningCount: Number(result[0].ticketDiningCount) || 0
            };
        }

        // 无数据时返回全0
        return {
            totalDiningCount: 0,
            mealDiningCount: 0,
            qcodeDiningCount: 0,
            cardDiningCount: 0,
            ticketDiningCount: 0
        };
    }

    /**
     * 3. 获取库存预警总数（实时库存 < 安全库存的食材数量）
     * @returns {Object} { total: 预警总数, list: 预警详情列表 }
     */
    async getInventoryWarningCount() {
        const sql = `
            SELECT 
                COUNT(*) AS warningTotal,  -- 预警总数
                -- 同时查询详情字段，便于需要时返回
                i.stock_id,
                i.goods_id,
                g.name AS goodsName,
                g.specification AS goodsSpec,
                i.house_id,
                h.name AS houseName,
                i.current_stock AS currentStock,
                i.safety_stock AS safetyStock,
                (i.safety_stock - i.current_stock) AS shortage  -- 缺口数量
            FROM ${this.tableName_inventory} i
            LEFT JOIN ${this.tableName_goods} g ON i.goods_id = g.goods_id
            LEFT JOIN house h ON i.house_id = h.house_id
            WHERE 
                i.status != '1'  -- 排除废弃状态
                AND i.current_stock < i.safety_stock  -- 严格小于安全库存
            GROUP BY i.stock_id  -- 按库存记录ID分组，确保count准确
            ORDER BY shortage DESC  -- 按缺口数量降序
        `;

        const [result] = await this.db.query(sql);
        console.log("库存预警查询结果：", sql);

        // 计算总预警数（result长度即为符合条件的记录数）
        const total = result.length;

        return {
            total,  // 预警总数
            list: result  // 预警详情列表（包含每个食材的缺口信息）
        };
    }

    /**
     * 4. 获取待采购订单的总数和总金额（仅统计待审核/待提交状态）
     */
    async getPendingProcurementSummary() {
        // 先查询待采购订单的总数（不依赖明细表）
        const countSql = `
            SELECT COUNT(plan_id) AS totalOrders 
            FROM ${this.tableName_plan} 
            WHERE status IN (1, 2)  -- 待审核、待提交
        `;

        // 执行总数查询
        const [countResult] = await this.db.query(countSql);
        const totalOrders = countResult[0]?.totalOrders || 0;

        // 再查询总金额（若明细表不存在，默认返回0）
        let totalAmount = 0;
        try {
            const amountSql = `
                SELECT IFNULL(SUM(gpi.plan_count * gpi.price), 0) AS totalAmount 
                FROM ${this.tableName_plan} gp
                LEFT JOIN goods_plan_item gpi ON gp.plan_id = gpi.plan_id 
                WHERE gp.status IN (1, 2)
            `;
            const [amountResult] = await this.db.query(amountSql);
            totalAmount = amountResult[0]?.totalAmount || 0;
        } catch (error) {
            // 若明细表不存在或关联失败，默认金额为0
            totalAmount = 0;
        }

        // 格式化金额为2位小数
        return {
            totalOrders: Number(totalOrders),
            totalAmount: Number(Number(totalAmount).toFixed(2))
        };
    }

    /**
     * 5. 每日用餐人数趋势（支持日期区间，默认过去14天）
     * @param {string} startDate - 开始日期（格式YYYY-MM-DD）
     * @param {string} endDate - 结束日期（格式YYYY-MM-DD）
     * @returns {Array} 按日期排序的每日用餐人数数据
     */
    async getDiningCountTrend(startDate = null, endDate = null) {
        // 计算默认日期区间：过去14天（包含今天）
        const today = new Date().toISOString().split('T')[0]; // 格式：YYYY-MM-DD
        const defaultEndDate = endDate || today;
        // 计算14天前的日期（当前日期 - 13天 = 14天区间）
        const defaultStartDate = startDate || (() => {
            const date = new Date();
            date.setDate(date.getDate() - 13);
            return date.toISOString().split('T')[0];
        })();

        // SQL：查询指定区间内的每日用餐人数，按日期升序排列
        const sql = `
            SELECT 
                log_date AS date,
                log_week AS week,
                meal_count AS mealDiningCount,        -- 包餐人数
                qcode_count AS qcodeDiningCount,      -- 培训部二维码人数
                card_count AS cardDiningCount,        -- 培训部卡机人数
                ticket_count AS ticketDiningCount,    -- 培训部餐票人数
                (qcode_count + card_count + ticket_count) AS facultyDiningCount  -- 总人数
            FROM ${this.tableName_daily}
            WHERE log_date BETWEEN ? AND ?
            ORDER BY log_date ASC
        `;

        const [result] = await this.db.query(sql, [defaultStartDate, defaultEndDate]);
        console.log("每日用餐人数趋势查询结果：", result);

        // 转换数字类型（避免数据库返回字符串）
        return result.map(item => ({
            date: item.date,
            week: item.week,
            mealDiningCount: Number(item.mealDiningCount) || 0,
            qcodeDiningCount: Number(item.qcodeDiningCount) || 0,
            cardDiningCount: Number(item.cardDiningCount) || 0,
            ticketDiningCount: Number(item.ticketDiningCount) || 0,
            facultyDiningCount: Number(item.facultyDiningCount) || 0
        }));
    }

    /**
     * 5. 每日用餐人数趋势（ECharts折线图专用格式，支持日期区间，默认过去14天）
     * @param {string} startDate - 开始日期（格式YYYY-MM-DD）
     * @param {string} endDate - 结束日期（格式YYYY-MM-DD）
     * @returns {Object} ECharts折线图所需数据（xAxis为日期，series为各类型数据）
     */
    async getDiningCountTrendEcharts(startDate = null, endDate = null) {
        // 1. 计算日期区间（逻辑同基础版）
        const today = new Date().toISOString().split('T')[0];
        const defaultEndDate = endDate || today;
        const defaultStartDate = startDate || (() => {
            const date = new Date();
            date.setDate(date.getDate() - 13);
            return date.toISOString().split('T')[0];
        })();

        // 2. 查询原始数据
        const sql = `
            SELECT 
                log_date AS date,
                log_week AS week,
                meal_count AS mealDiningCount,
                qcode_count AS qcodeDiningCount,
                card_count AS cardDiningCount,
                ticket_count AS ticketDiningCount,
                (qcode_count + card_count + ticket_count) AS facultyDiningCount
            FROM ${this.tableName_daily}
            WHERE log_date BETWEEN ? AND ?
            ORDER BY log_date ASC
        `;
        const [result] = await this.db.query(sql, [defaultStartDate, defaultEndDate]);
        // console.log("ECharts趋势数据查询结果：", result);

        // 3. 转换为ECharts折线图格式
        // 3.1 x轴数据（日期列表，如：['2025-10-01', '2025-10-02', ...]）
        const xAxisData = result.map(item => item.date);

        // 3.2 系列数据（每条线对应一个数据系列）
        const series = [
            {
                name: '包餐人数',
                type: 'line',
                data: result.map(item => Number(item.mealDiningCount) || 0),
                smooth: true
            },
            {
                name: '教工餐人数',
                type: 'line',
                data: result.map(item => Number(item.facultyDiningCount) || 0),
                smooth: true
            }
        ];

        // 4. 返回完整ECharts配置数据
        return {
            rawList: result, // 原始数据列表
            xAxisData, // x轴刻度（日期）
            series,    // 系列数据（各类型人数）
            // 补充区间信息，方便前端展示
            dateRange: {
                start: defaultStartDate,
                end: defaultEndDate
            }
        };
    }

    /**
     * 6. 营收趋势（支持日期区间，默认最近7天）
     * @param {string} startDate - 开始日期（格式YYYY-MM-DD）
     * @param {string} endDate - 结束日期（格式YYYY-MM-DD）
     * @returns {Object} ECharts折线图格式的营收趋势数据
     */
    async getRevenueTrend(startDate = null, endDate = null) {
        // 计算默认日期区间：最近7天（包含今天）
        const today = new Date().toISOString().split('T')[0];
        const defaultEndDate = endDate || today;
        // 计算7天前的日期（当前日期 - 6天 = 7天区间）
        const defaultStartDate = startDate || (() => {
            const date = new Date();
            date.setDate(date.getDate() - 6);
            return date.toISOString().split('T')[0];
        })();

        // SQL：查询指定区间内的每日营收数据
        const sql = `
            SELECT 
                log_date AS date,
                log_week AS week,
                total_sales AS totalRevenue,          -- 总营业额
                meal_sales AS mealRevenue,            -- 包餐营业额
                qcode_sales AS qcodeRevenue,          -- 培训部二维码营业额
                card_sales AS cardRevenue,            -- 培训部卡机营业额
                ticket_sales AS ticketRevenue,        -- 培训部餐票营业额
                room_food_sales AS roomRevenue        -- 包间营业额
            FROM ${this.tableName_daily}
            WHERE log_date BETWEEN ? AND ?
            ORDER BY log_date ASC
        `;

        const [result] = await this.db.query(sql, [defaultStartDate, defaultEndDate]);
        console.log("营收趋势查询结果：", result);

        // 转换为ECharts折线图格式
        const xAxisData = result.map(item => item.date);
        const series = [
            {
                name: '总营业额',
                type: 'line',
                data: result.map(item => Number(item.totalRevenue) || 0),
                smooth: true,
                lineStyle: { width: 3 },
                emphasis: { focus: 'series' }
            },
            {
                name: '包餐营业额',
                type: 'line',
                data: result.map(item => Number(item.mealRevenue) || 0),
                smooth: true
            },
            {
                name: '培训部二维码',
                type: 'line',
                data: result.map(item => Number(item.qcodeRevenue) || 0),
                smooth: true
            },
            {
                name: '培训部卡机',
                type: 'line',
                data: result.map(item => Number(item.cardRevenue) || 0),
                smooth: true
            },
            {
                name: '培训部餐票',
                type: 'line',
                data: result.map(item => Number(item.ticketRevenue) || 0),
                smooth: true
            },
            {
                name: '包间营业额',
                type: 'line',
                data: result.map(item => Number(item.roomRevenue) || 0),
                smooth: true
            }
        ];

        return {
            rawList: result,
            xAxisData,
            series,
            dateRange: {
                start: defaultStartDate,
                end: defaultEndDate
            }
        };
    }


    /**
     * 7. 采购物品分类统计（按分类汇总采购总数，适配ECharts饼状图）
     * @param {string} startDate - 开始日期（格式YYYY-MM-DD，可选，默认全部）
     * @param {string} endDate - 结束日期（格式YYYY-MM-DD，可选，默认全部）
     * @param {Array} statusList - 订单状态筛选（可选，默认统计全部状态订单）
     * @returns {Object} 分类统计数据（含原始列表和饼状图格式数据）
     */
    async getPurchaseCategoryStat(startDate = null, endDate = null, statusList = null) {
        // 构建筛选条件数组
        const whereConditions = [];
        const queryParams = [];

        // 1. 订单状态筛选：若传递statusList则筛选，否则统计全部
        if (statusList && statusList.length > 0) {
            whereConditions.push(`go.status IN (${statusList.map(() => '?').join(',')})`);
            queryParams.push(...statusList); // 批量添加状态参数
        }

        // 2. 日期区间筛选：若传递日期则添加，否则不限制
        if (startDate && endDate) {
            whereConditions.push(`go.order_date BETWEEN ? AND ?`);
            queryParams.push(startDate, endDate);
        } else if (startDate) {
            whereConditions.push(`go.order_date >= ?`);
            queryParams.push(startDate);
        } else if (endDate) {
            whereConditions.push(`go.order_date <= ?`);
            queryParams.push(endDate);
        }

        // 拼接WHERE子句（若有条件则添加，否则不限制）
        const whereSql = whereConditions.length > 0
            ? `WHERE ${whereConditions.join(' AND ')}`
            : '';

        // SQL逻辑：关联表+条件筛选+分组统计
        const sql = `
            SELECT 
                c.cate_id AS categoryId,
                c.name AS categoryName,
                c.cate_order AS sortOrder,
                -- 汇总该分类下的采购总数（保留2位小数）
                ROUND(SUM(goi.ordered_count), 2) AS totalPurchaseCount,
                -- 汇总该分类采购总金额
                ROUND(SUM(goi.amount), 2) AS totalPurchaseAmount
            FROM ${this.tableName_category} c
            -- 关联食材表：只统计启用的食材
            LEFT JOIN ${this.tableName_goods} g 
                ON c.cate_id = g.cate_id AND g.status = 1
            -- 关联采购订单明细表
            LEFT JOIN ${this.tableName_goods_order_item} goi 
                ON g.goods_id = goi.goods_id
            -- 关联采购订单主表
            LEFT JOIN ${this.tableName_goods_order} go 
                ON goi.order_id = go.order_id 
            ${whereSql}  -- 动态拼接筛选条件
            -- 按分类分组
            GROUP BY c.cate_id, c.name, c.cate_order
            -- 按分类排序字段升序
            ORDER BY c.cate_order ASC
        `;

        const [result] = await this.db.query(sql, queryParams);
        console.log("采购物品分类统计结果：", result);

        // 转换为ECharts饼状图格式
        const pieChartData = result.map(item => ({
            name: item.categoryName,
            value: Number(item.totalPurchaseCount) || 0, // 饼图数值为采购总数
            extend: {
                totalAmount: item.totalPurchaseAmount, // 采购总金额
                sortOrder: item.sortOrder
            }
        })).filter(item => item.value > 0); // 过滤无采购记录的分类

        return {
            rawList: result,          // 原始统计数据（含ID、金额等）
            pieChartData: pieChartData// ECharts饼状图数据
        };
    }

    // /** ---依据采购订单表
    //  * 8. 采购成本分析（按类别统计采购总金额，适配ECharts柱状图）
    //  * @param {Array} statusList - 订单状态筛选（默认有效订单：3-已确认/4-配送中/5-部分入库/6-已完成）
    //  * @param {string} startDate - 开始日期（格式YYYY-MM-DD，可选）
    //  * @param {string} endDate - 结束日期（格式YYYY-MM-DD，可选）
    //  * @returns {Object} 分类采购金额数据（含X轴、Y轴及原始明细）
    //  */
    // async getPurchaseCostAnalysis(statusList = [3, 4, 5, 6], startDate = null, endDate = null) {
    //     // 构建日期筛选条件（若传递日期参数则添加）
    //     const dateWhere = [];
    //     const queryParams = [...statusList]; // 先放入状态参数
    //     if (startDate && endDate) {
    //         dateWhere.push(`go.order_date BETWEEN ? AND ?`);
    //         queryParams.push(startDate, endDate);
    //     } else if (startDate) {
    //         dateWhere.push(`go.order_date >= ?`);
    //         queryParams.push(startDate);
    //     } else if (endDate) {
    //         dateWhere.push(`go.order_date <= ?`);
    //         queryParams.push(endDate);
    //     }

    //     // 拼接WHERE条件
    //     const whereConditions = [
    //         `go.status IN (${statusList.map(() => '?').join(',')})`,
    //         ...dateWhere
    //     ].join(' AND ');

    //     // SQL：按类别分组统计采购总金额
    //     const sql = `
    //         SELECT 
    //             c.cate_id AS categoryId,
    //             c.name AS categoryName,
    //             c.cate_order AS sortOrder,
    //             -- 汇总该分类采购总金额（保留2位小数）
    //             ROUND(IFNULL(SUM(goi.amount), 0), 2) AS totalAmount,
    //             -- 统计该分类下的采购订单数
    //             COUNT(DISTINCT go.order_id) AS orderCount
    //         FROM ${this.tableName_category} c
    //         -- 关联食材表（只统计启用的食材）
    //         LEFT JOIN ${this.tableName_goods} g 
    //             ON c.cate_id = g.cate_id AND g.status = 1
    //         -- 关联采购明细表
    //         LEFT JOIN ${this.tableName_goods_order_item} goi 
    //             ON g.goods_id = goi.goods_id
    //         -- 关联采购订单表（筛选有效订单和日期）
    //         LEFT JOIN ${this.tableName_goods_order} go 
    //             ON goi.order_id = go.order_id
    //         WHERE ${whereConditions}
    //         GROUP BY c.cate_id, c.name, c.cate_order
    //         ORDER BY c.cate_order ASC  -- 按分类排序
    //     `;

    //     const [result] = await this.db.query(sql, queryParams);
    //     console.log("采购成本分析查询结果：", result);

    //     // 转换为ECharts柱状图格式
    //     const xAxisData = result.map(item => item.categoryName); // X轴：类别名称
    //     const seriesData = result.map(item => ({
    //         name: item.categoryName,
    //         value: Number(item.totalAmount), // Y轴：总金额
    //         orderCount: item.orderCount      // 附加：该分类的订单数
    //     }));

    //     return {
    //         rawList: result,    // 原始数据（含ID、排序等）
    //         xAxisData,          // X轴数据（类别名）
    //         seriesData,         // 系列数据（含金额和订单数）
    //         filter: {
    //             statusList,
    //             startDate,
    //             endDate
    //         }
    //     };
    // }


    /**--依据出库单表
     * 8. 采购成本分析（按类别统计出库总金额，适配ECharts柱状图）
     * @param {Array} statusList - 出库单状态筛选（默认有效出库：2-已出库）
     * @param {string} startDate - 开始日期（格式YYYY-MM-DD，可选）
     * @param {string} endDate - 结束日期（格式YYYY-MM-DD，可选）
     * @param {Array} purposeList - 出库用途筛选（默认日常烹饪：1-日常烹饪，可选：2-报损出库, 3-销售出库, 4-其他）
     * @returns {Object} 分类出库金额数据（含X轴、Y轴及原始明细）
     */
    async getPurchaseCostAnalysis(
        statusList = [2], // 出库单有效状态：2-已出库（原采购单状态替换为出库单状态）
        startDate = null,
        endDate = null,
        purposeList = [1, 2, 3, 4] // 新增：出库用途筛选（默认日常烹饪）
    ) {
        // 构建筛选条件
        const whereConditions = [];
        const queryParams = [];

        // 1. 出库单状态筛选（inventoryout.status）
        if (statusList && statusList.length > 0) {
            whereConditions.push(`io.status IN (${statusList.map(() => '?').join(',')})`);
            queryParams.push(...statusList);
        }

        // 2. 出库用途筛选（inventoryout.purpose）
        if (purposeList && purposeList.length > 0) {
            whereConditions.push(`io.purpose IN (${purposeList.map(() => '?').join(',')})`);
            queryParams.push(...purposeList);
        }

        // 3. 日期筛选（出库时间：inventoryout.out_time）
        if (startDate && endDate) {
            whereConditions.push(`DATE(io.out_time) BETWEEN ? AND ?`);
            queryParams.push(startDate, endDate);
        } else if (startDate) {
            whereConditions.push(`DATE(io.out_time) >= ?`);
            queryParams.push(startDate);
        } else if (endDate) {
            whereConditions.push(`DATE(io.out_time) <= ?`);
            queryParams.push(endDate);
        }

        // 拼接WHERE子句（无筛选条件时不拼接）
        const whereClause = whereConditions.length ? `WHERE ${whereConditions.join(' AND ')}` : '';

        // SQL：按类别分组统计出库总金额（适配新表关联逻辑）
        const sql = `
            SELECT 
            c.cate_id AS categoryId,
            c.name AS categoryName,
            c.cate_order AS sortOrder,
            -- 汇总该分类出库总金额（保留2位小数，直接使用出库单总金额，若有明细则 SUM(明细金额)）
            ROUND(IFNULL(SUM(io.total_amount), 0), 2) AS totalAmount,
            -- 统计该分类下的出库单数
            COUNT(DISTINCT io.out_id) AS orderCount
            FROM ${this.tableName_category} c
            -- 关联食材表（只统计启用的食材）
            LEFT JOIN ${this.tableName_goods} g 
            ON c.cate_id = g.cate_id AND g.status = 1
            -- 关联出库单明细表（假设存在出库单明细表，若没有则直接关联出库单主表）
            -- 注意：如果没有出库单明细表，需删除此关联，直接用 io.total_amount 汇总
            LEFT JOIN ${this.tableName_inventoryout_item} ioi  -- 假设出库单明细表名：inventoryout_item（需根据实际表名调整）
            ON g.goods_id = ioi.goods_id
            -- 关联出库单主表（核心替换：原采购单表 -> 出库单表）
            LEFT JOIN ${this.tableName_inventoryout} io 
            ON ioi.out_id = io.out_id  -- 若有明细表则关联明细表，无则直接关联（如：g.goods_id = io.goods_id，需根据实际表结构调整）
            ${whereClause}
            GROUP BY c.cate_id, c.name, c.cate_order
            ORDER BY c.cate_order ASC  -- 按分类排序
        `;

        // 特殊说明：
        // 1. 若不存在出库单明细表（inventoryout_item），需修改关联逻辑：
        //    - 直接关联出库单主表（需确保出库单主表有 goods_id 字段，或通过其他字段关联）
        //    - 调整SQL为：LEFT JOIN ${this.tableName_inventoryout} io ON g.goods_id = io.goods_id
        // 2. 若出库单主表的 total_amount 已汇总该单所有食材金额，直接 SUM(io.total_amount) 即可
        // 3. 请根据实际数据库中是否存在「出库单明细表」调整上述关联逻辑

        const [result] = await this.db.query(sql, queryParams);
        console.log("出库成本分析查询结果：", result);

        // 转换为ECharts柱状图格式（保持原有格式不变，前端无需适配）
        const xAxisData = result.map(item => item.categoryName); // X轴：类别名称
        const seriesData = result.map(item => ({
            name: item.categoryName,
            value: Number(item.totalAmount), // Y轴：总金额
            orderCount: item.orderCount      // 附加：该分类的出库单数
        }));

        return {
            rawList: result,    // 原始数据（含ID、排序等）
            xAxisData,          // X轴数据（类别名）
            seriesData,         // 系列数据（含金额和出库单数）
            filter: {
                statusList,
                purposeList, // 新增：返回用途筛选条件
                startDate,
                endDate
            }
        };
    }

    /**
     * 9. 月度经营分析对比（一年内每月的总营收、采购成本、利润）
     * @param {number} year - 年份（如2025，默认当前年份）
     * @returns {Object} 月度经营数据（适配ECharts多柱形图）
     */
    async getMonthlyBusinessAnalysis(year = null) {
        // 默认使用当前年份
        const targetYear = year || new Date().getFullYear();
        // 构建1-12月的基础数据结构（确保每个月都有记录，无数据则填充0）
        const monthData = Array.from({ length: 12 }, (_, i) => ({
            month: i + 1, // 1-12月
            totalRevenue: 0, // 总营收
            purchaseCost: 0, // 采购成本
            profit: 0 // 利润（营收-成本）
        }));

        // --------------------------
        // 1. 统计每月总营收（来自daily_logs）
        // --------------------------
        const revenueSql = `
            SELECT 
                MONTH(log_date) AS month,
                ROUND(SUM(total_sales), 2) AS totalRevenue
            FROM ${this.tableName_daily}
            WHERE YEAR(log_date) = ?
            GROUP BY MONTH(log_date)
        `;
        const [revenueResult] = await this.db.query(revenueSql, [targetYear]);
        console.log("月度总营收查询结果：", revenueResult);
        // 填充营收数据到对应月份
        revenueResult.forEach(item => {
            const monthIndex = item.month - 1; // 转换为0-11索引
            monthData[monthIndex].totalRevenue = Number(item.totalRevenue) || 0;
        });

        // --------------------------
        // 2. 统计每月采购成本（来自采购订单明细）
        // --------------------------
        const costSql = `
            SELECT 
                MONTH(go.order_date) AS month,
                ROUND(SUM(goi.amount), 2) AS purchaseCost
            FROM ${this.tableName_goods_order} go
            LEFT JOIN ${this.tableName_goods_order_item} goi 
                ON go.order_id = goi.order_id
            WHERE 
                YEAR(go.order_date) = ?
                AND go.status NOT IN (0, 2)  -- 排除作废和取消的订单
            GROUP BY MONTH(go.order_date)
        `;
        const [costResult] = await this.db.query(costSql, [targetYear]);
        console.log("月度采购成本查询结果：", costResult);
        // 填充采购成本到对应月份
        costResult.forEach(item => {
            const monthIndex = item.month - 1;
            monthData[monthIndex].purchaseCost = Number(item.purchaseCost) || 0;
        });

        // --------------------------
        // 3. 计算每月利润（总营收 - 采购成本）
        // --------------------------
        monthData.forEach(item => {
            item.profit = Number((item.totalRevenue - item.purchaseCost).toFixed(2));
        });

        // 转换为ECharts多柱形图格式
        const xAxisData = monthData.map(item => `${item.month}月`); // X轴：1月-12月
        const series = [
            {
                name: '总营收',
                type: 'bar',
                data: monthData.map(item => item.totalRevenue),
                itemStyle: { color: '#32CD32' } // 绿色：营收
            },
            {
                name: '采购成本',
                type: 'bar',
                data: monthData.map(item => item.purchaseCost),
                itemStyle: { color: '#FF6347' } // 红色：成本
            },
            {
                name: '利润',
                type: 'bar',
                data: monthData.map(item => item.profit),
                itemStyle: { color: '#1E90FF' } // 蓝色：利润
            }
        ];

        return {
            year: targetYear,
            xAxisData,
            series,
            rawList: monthData // 原始月度数据（含详细数值）
        };
    }

    /**
     * 10. 最近活动（用户近期操作日志记录）
     * @param {string} startDate - 开始时间（格式YYYY-MM-DD HH:MM:SS，可选）
     * @param {string} endDate - 结束时间（格式YYYY-MM-DD HH:MM:SS，可选）
     * @param {number} limit - 返回条数，默认7条
     * @returns {Array} 日志记录列表（按时间倒序，含操作人信息）
     */
    async getRecentActivities(startDate = null, endDate = null, limit = 7) {
        // 构建筛选条件
        const whereConditions = [];
        const queryParams = [];

        // 时间范围筛选
        if (startDate && endDate) {
            whereConditions.push(`sl.create_time BETWEEN ? AND ?`);
            queryParams.push(startDate, endDate);
        } else if (startDate) {
            whereConditions.push(`sl.create_time >= ?`);
            queryParams.push(startDate);
        } else if (endDate) {
            whereConditions.push(`sl.create_time <= ?`);
            queryParams.push(endDate);
        }

        // 拼接WHERE子句
        const whereSql = whereConditions.length > 0
            ? `WHERE ${whereConditions.join(' AND ')}`
            : '';

        // SQL查询：关联user表，查询操作人信息，按时间倒序
        const sql = `
            SELECT 
                sl.id,
                sl.op_type AS opType,        -- 操作类型
                sl.op_desc AS opDesc,        -- 操作描述
                sl.ip,                       -- 操作IP
                sl.user_id AS userId,        -- 操作人ID（新增）
                u.user_name AS operatorName,  -- 操作人用户名（关联user表获取，新增）
                sl.create_time AS createTime -- 操作时间
            FROM ${this.tableName_sys_logs} sl
            -- 左关联user表（保留无操作人ID的日志，如匿名操作）
            LEFT JOIN ${this.tableName_user} u 
                ON sl.user_id = u.user_id
            ${whereSql}
            ORDER BY sl.create_time DESC
            LIMIT ?
        `;
        queryParams.push(limit); // 添加条数限制参数

        const [result] = await this.db.query(sql, queryParams);
        console.log("最近活动日志查询结果：", result);

        // 转换时间格式为字符串（便于前端展示），处理空值
        return result.map(log => ({
            ...log,
            userId: log.userId || null, // 无操作人时返回null
            operatorName: log.operatorName || '匿名用户', // 无用户名时显示默认值
            createTime: log.createTime ? new Date(log.createTime).toISOString() : null
        }));
    }
}

module.exports = DataLookModel;